Chaque joueur peut posséder plusieurs personnages actifs, chacun se situant dans un lieu donné.
Stockons l'ensemble des lieux occupés par les personnages du joueur C au tour 8 dans le tuple C_tour8.

Supposons que C_tour8 = (("antre_orcs", 85, 36, True), ("chateau_C", -105.2, 23, True))

Écrire les lignes de code qui affichent :

1. "chateau_C", -105.2, 23, True

2. "chateau_C"

3. -105.2,23

Écrire une fonction triangle_rect(n) qui renvoie un tuple où chaque élément est un tuple de longueur trois, ces tuples sont constitués de trois entiers a, b,c tels que $0<a\leq b\leq c < n$ et le triangle de cotés $a$, $b$ et $c$ soit rectangle. Le tuple renvoyé doit contenir tous les triplets possibles.

Par exemple triangle_rect(20) renvoie le tuple ((3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15)).

Le Delta encoding (ou codage par différence en français) est une des techniques pour compresser un tableau de valeurs.
Plutôt que de stocker la valeur elle-même, on stocke sa différence avec la valeur précédente.
Ainsi, lorsque les valeurs sont grandes, mais varient peu, les différences sont petites si bien que moins de bits sont nécessaires pour représenter en mémoire ces nombres.

Supposons, par exemple, la liste des salaires d'une entreprise suivant : salaires = [1745, 1685, 1701, 1796, 1864, 1825].
Plutôt que de stocker cette liste, il suffit de stocker la liste salaires_delta = [1745, -60, 16, 95, 68, -39].

1. Écrire une fonction delta prenant en paramètre une liste de nombres et renvoyant la liste obtenue par le codage par différence.

2. Tester la fonction écrite, par exemple avec la liste salaires = [1745, 1685, 1701, 1796, 1864, 1825].

Dans cet exercice, vous devez écrire deux scripts Python qui créent la liste des entiers de 0 à 10000 de deux méthodes différentes :

1. En extension.

2. En compréhension.

1. Créer en extension une liste qui contienne les nombres pairs inférieurs à 10000.

2. Créer en compréhension une liste qui contienne les nombres pairs inférieurs à 10000.

3. Créer en compréhension une liste qui contienne les nombres impairs inférieurs à 10000.

Tableaux et fonctions

Voici une fonction dont l'en-tête est incomplète ; il manque le type de retour

def test(a: list) -> ...:
	return [x**2 for x in a if x > 0], [x for x in a if x > 10]
# une liste pour tester la fonction
a = [-4, -3, -2, 0, 1, 5, 9, 11]
		

1. Décrire le type du retour de la fonction et le rajouter à l'en-tête.

2. Expliquer ce que fait cette fonction et le rajouter comme documentation à cette fonction.

Voici un programme en python :

import random 

liste = [random.randint(1, 6) for i in range(1000)] 

1. Que contient la liste liste ?

2. Combien d'éléments contient cette liste ?
   Vérifier en utilisant un script Python.

3. Écrire un script Python qui renvoie une liste formé de six nombres entiers :

   • Le premier entier donne le nombre de 1 dans la liste liste.

   • Le deuxième entier donne le nombre de 2 dans la liste liste.

   • ...

   • Le sixième entier donne le nombre de 6 dans la liste liste.

   Utiliser la la méthode count.

4. Quelle instruction écrire pour enlever l'avant-dernier terme de la liste ?

5. Quelle instruction écrire pour enlever la première occurrence du nombre 6 de la liste ?

Le but de cet exercice est d'écrire une fonction "compter" sans utiliser count

1. Écrire une fonction compter(element, liste) qui a pour paramètres un entier element et une liste d'entiers liste qui renvoie le nombre d'occurrences de element dans liste.

2. Utiliser la fonction compter pour refaire l'exercice précédent.

3. Prolongement possible : remplacer element par une liste d'éléments dans les arguments de la fonction compter.

L = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

Le premier élément de la liste L est la liste [1, 2, 3, 4] ; pour l'afficher on écrit : L[0].

Le troisième élément de cette liste [1, 2, 3, 4], notée L[0], est 3 ; pour y accéder nous utiliserons L[0][2]

1. Afficher le quatrième élément du deuxième élément de la liste.

2. Afficher le deuxième élément du troisième élément de la liste.

3. Afficher l'élément indexé 0 du deuxième élément de la liste.

4. Afficher L[2][3].

5. Ajouter la valeur 26 à la deuxième liste. L est-elle encore une matrice ?

Écrire une fonction matriceAlea(n: int, m: int) -> list en langage Python qui renvoie une matrice à n lignes et m colonnes d'entiers aléatoires entre 0 et 100.

Proposer une fonction entiers_en_matrice qui prend en paramètres deux nombres entiers n et m et qui renvoie la matrice formée par tous les nombres entiers compris entre 0 et $m\times n-1$ de telle sorte que ces nombres entiers soient rangés par ordre croissant lors du parcours de la matrice suivant chaque ligne de "haut en bas".
Par exemple, entiers_en_matrice(3, 5) renvoie [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]] et entiers_en_matrice(4, 1) renvoie [[0], [1], [2], [3]]

Une image en noir et blanc peut être codée pixel par pixel informatiquement par un tableau en deux dimensions formés de 0 et de 1, où le 1 code noir et 0 blanc.
Voici une telle image :

1. Proposer un tableau 2D en langage Python représentant le codage en noir et blanc de l'image ci-dessus.

2. Le négatif d'une image en noir et blanc est une image de même taille où dans la représentation informatique les 1 ont été changé en 0 et où les 0 ont été changé en 1.
   Proposer une fonction creer_negatif qui prend en paramètre un tableau 2d sous forme de liste de listes et qui renvoie le tableau 2D où tous les 1 et les 0 ont été changés en leur complémentaire.

3. Tester la fonction sur le tableau 2D représentant l'image ci-dessus.

Le chiffrement Playfair a été développé au XIXème siècle et utilisé par l'armée britannique durant les guerres du XXème siècle, est basé sur le chiffrement de paires de lettres.
On dispose les lettres de l'alphabet (le W étant exclu dans l'utilisation de ce chiffrement en France) dans une grille carrée 5X5 comme par exemple le tableau ci-dessous :

Source : vikidia.org

1. On considère une liste lettres de 25 lettres différentes de l'alphabet.
   Le but est de construire à partir d'elle une grille de 5 par 5, comme celle utilisée pour le chiffrement de playfair.

   Compléter la fonction creer_carre_playfair ci-dessous qui prend en paramètre une liste de 25 lettres différentes de l'alphabet et renvoie un tableau 2D représentant le carré de chiffrement de Playfair associé.

   def creer_carre_playfair(liste_clef):
       carre = [[...] for j in range(...)] # création d'une grille nulle de 5 par 5
       for i in range(25):
           carre[...][...] = liste_clef[i]
       return ...

   Les opérateurs % et // de la division euclidienne peuvent être utiles ici.

   Voici un test possible :

   >>> lettres = ['P', 'L', 'A', 'Y', 'F', 'I', 'R', 'B', 'C', 'D', 'E', 'G', 'H', 'J', 'K', 'M', 'N', 'O', 'Q', 'S', 'T', 'U', 'V', 'X', 'Z']
   >>> creer_carre_playfair(lettres)
   [['P', 'L', 'A', 'Y', 'F'], ['I', 'R', 'B', 'C', 'D'], ['E', 'G', 'H', 'J', 'K'], ['M', 'N', 'O', 'Q', 'S'], ['T', 'U', 'V', 'X', 'Z']]

2. Dans le script de la fonction précédente creer_carre_playfair, rajouter deux préconditions sur le paramètre liste_clef afin de vérifier que cette liste ait bien 25 éléments mais pas la lettre W.

3. Donner le code Python de la fonction ligne_colonne qui prend en paramètres une lettre majuscule carac et un carré de chiffrement carre créé par la fonction creer_carre, et qui renvoie les coordonnées de la lettre carac dans le carré de chiffrement carre.
   On suppose ici que la lettre majuscule apparaît toujours dans le carré.
   Deux tests proposés :

   >>> carre = [['P', 'L', 'A', 'Y', 'F'], ['I', 'R', 'B', 'C', 'D'], ['E', 'G', 'H', 'J', 'K'], ['M', 'N', 'O', 'Q', 'S'], ['T', 'U', 'V', 'X', 'Z']]
   >>> ligne_colonne('A', carre)
   (0, 2)
   >>> ligne_colonne('N', carre)
   (3, 1)                    

Le but de cet exercice est de représenter un jeu de 32 cartes.

Un jeu de 32 cartes est composé de :

• quatre couleurs : pique, cœur, carreau, trèfle,

• huit valeurs : roi, dame, valet, 1, 10, 9, 8, 7.

1. Modélisation du problème.

   1. Comment modéliser une carte en Python ?

   2. Comment modéliser un jeu de cartes ?

   Code de déblocage de la correction :

2. Implémentation en Python.

   Le but est d'implémenter un jeu de 32 cartes et se doter de fonctions qui permettent interagir avec ce jeu.

   Lorsque vous écrivez des fonctions :

   • Il faut typer vos fonctions. Exemple : creation_jeu32(couleur: tuple, valeur32: tuple) -> list

   • Il faut écrire une aide explicative docstring, entre " ", ou entre """ """" (si l'aide fait plusieurs lignes).

   Dans cette partie, on suppose disposer de deux tuples :

   • couleur = ("pique", "cœur", "carreau", "trèfle").

   • valeur32 = ("Roi", "Dame", "Valet", 1, 10, 9, 8, 7).

   Dans cette partie une carte sera donnée comme un tuple formé d'une valeur et d'une couleur, comme par exemple la carte ("Dame", "cœur").

   1. Créer une fonction creation_jeu32(couleur: tuple, valeur32: tuple) -> list qui retourne une liste de 32 cartes.

   2. Vérifier que le jeu créé avec la fonction précédente possède bien 32 cartes.

   3. On veut pouvoir mélanger le jeu de 32 cartes.
      Il existe une fonction shuffle de la bibliothèque random qui mélange "sur place" les éléments d'une liste : random.shuffle(liste) modifie ainsi la liste liste en mélangeant aléatoirement l'ordre de ses éléments, sans créer une nouvelle liste.
      Écrire une fonction melange(jeu: list) -> list qui renvoie le jeu de cartes mélangées.

   4. On veut pouvoir tirer une carte au hasard du jeu. Si le jeu est mélangé, cela peut être la première carte.
      Il faut ed plus penser à retirer la carte du jeu.
      Créer ainsi une fonction carte_hasard qui prend en paramètre une liste jeu et renvoie un tuple formé de la carte tirée et de la liste des cartes restant dans le jeu une fois la carte tirée.

   5. On veut pouvoir créer une "main" de 5 cartes. Une main signifie un ensemble de cartes.
      Écrire une fonction main(nombre_cartes: int, jeu: list) -> tuple qui renvoie une main formée du nombre de cartes et la liste formée du reste des cartes du jeu.

      Ne pas oublier de retirer la main créée du jeu de 32 cartes renvoyé comme reste.

Code de déblocage de la correction :

3. Autre modèle possible.

   On veut pouvoir comparer des cartes pour réaliser par exemple des jeux.

   1. Modélisation

      1. Comment modéliser la "force" d'une carte ?

      2. Comment modéliser le jeu de cartes avec la force de chaque carte ?

   2. Implémentation en Python

      1. Écrire une fonction force(carte: tuple) -> int: qui renvoie la "force" de la carte.

      2. Écrire une fonction jeu_force(jeu) qui renvoie le jeu des cartes associées à leur force.

      3. On veut comparer deux cartes. Écrire une fonction en Python compare(carte1: tuple, carte2: tuple) -> tuple qui renvoie la carte avec la force la plus élevée.

      4. Inventer une notion de distance entre deux cartes. Écrire une fonction distance(carte1: tuple, carte2: tuple) -> int qui renvoie la "distance" entre deux cartes.

Le prolongement de cette activité est la création d'un jeu (bataille, rami, blackjack, poker, pyramide, etc.). La création d'un jeu pourra être développée dans le cadre de votre projet.

Python considère une phrase comme une séquence. Vous pouvez réaliser des essais avec cette citation célèbre du philosophe Confucius : "Je ne cherche pas à connaître les réponses, je cherche à comprendre les questions." De quelle type de séquence se rapproche-t-on? De la liste et/ou du tuple ? Faire des tests à partir de vos connaissances en python.

# -*- coding: utf-8 -*-
citation="Je ne cherche pas à connaître les réponses, je cherche à comprendre les questions."

# Quelques tests à faire :
citation[3]
citation[4] = 'z'
citation.append('!')

# En chercher d'autres 

En utilisant la méthode count(elt), compter le nombre de 'a' dans la citation, le nombre de 'e', le nombre de voyelles, etc.

Il existe pour les listes des méthodes très intéressantes dans le traitement des chaînes de caractères. Ce sont les méthodes split() et join().

1. Exécuter le code suivant en faisant afficher le contenu des différents objets :

   # -*- coding: utf-8 -*-
   
   citation = "Je ne cherche pas à connaître les réponses, je cherche à comprendre les questions."
   
   liste = citation.split(" ")
   
   phrase2 = " ".join(liste)
   
   # Afficher le contenu des différentes variables afin de comprendre les méthodes split et join
   # Faire des tests sur d'autres phrases 

   Vous pouvez utiliser directement ce bac à sable Trinket.

2. Quel est le rôle des méthodes split et join ?

3. En utilisant ces principes, comment faire pour créer une liste de mots à partir de la chaîne de caractères suivante : chaine = "un,deux,trois,quatre,cinq" ?

Extraire des groupes aléatoires.

L'objectif est de créer une fonction groupe(taille, nom_csv) qui prend pour argument un entier : taille correspondant à la taille des groupes voulus et une chaîne de caractères nom_csv correspondant au nom du fichier csv qui renvoie la répartition des groupes à la bonne taille de manière aléatoire.

Le matériel nécessaire se compose d'un fichier csv téléchargeable ici.

Chaque individu possède trois attributs Nom, Prenom et Race (orc ou gobelin).

Les individus sont des "peaux vertes" constitués d'orcs et de gobelins.

Prolongement possible :

1. Réécrire la fonction précédente qui ajoute un numero de groupe à chaque groupe.

Code de déblocage de la correction :

2. Faire en sorte de réécrire un csv avec la liste des élèves avec leur numéro de groupe.